.TH deductionguidesforstd::list 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
deductionguidesforstd::list \- deductionguidesforstd::list

.SH Synopsis
   Defined in header <list>
   template< class InputIt,

             class Alloc = std::allocator<
                 typename std::iterator_traits<InputIt>::value_type>
   >                                                                  \fB(1)\fP \fI(since C++17)\fP
   list( InputIt, InputIt, Alloc = Alloc() )

       -> list<typename std::iterator_traits<InputIt>::value_type,
   Alloc>;
   template< ranges::input_range R,

             class Alloc = std::allocator<ranges::range_value_t<R>> > \fB(2)\fP (since C++23)
   list( std::from_range_t, R&&, Alloc = Alloc() )

       -> list<ranges::range_value_t<R>, Alloc>;

   1) This deduction guide is provided for list to allow deduction from an iterator
   range. This overload participates in overload resolution only if InputIt satisfies
   LegacyInputIterator and Alloc satisfies Allocator.
   2) This deduction guide is provided for list to allow deduction from a
   std::from_range_t tag and an input_range.

   Note: the extent to which the library determines that a type does not satisfy
   LegacyInputIterator is unspecified, except that as a minimum integral types do not
   qualify as input iterators. Likewise, the extent to which it determines that a type
   does not satisfy Allocator is unspecified, except that as a minimum the member type
   Alloc::value_type must exist and the expression
   std::declval<Alloc&>().allocate(std::size_t{}) must be well-formed when treated as
   an unevaluated operand.

.SH Notes

       Feature-test macro       Value    Std                   Feature
   __cpp_lib_containers_ranges 202202L (C++23) Ranges-aware construction and insertion;
                                               overload \fB(2)\fP

.SH Example


// Run this code

 #include <list>
 #include <vector>

 int main()
 {
     std::vector<int> v = {1, 2, 3, 4};

     // uses explicit deduction guide to deduce std::list<int>
     std::list x(v.begin(), v.end());

     // deduces std::list<std::vector<int>::iterator>
     // first phase of overload resolution for list-initialization selects the candidate
     // synthesized from the initializer-list constructor; second phase is not performed
     // and deduction guide has no effect
     std::list y{v.begin(), v.end()};
 }
